////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2017-2018 Qualcomm Technologies, Inc.
// All Rights Reserved.
// Confidential and Proprietary - Qualcomm Technologies, Inc.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @file  camxcasdstatsprocessor.h
/// @brief The class that implements IStatsProcessor for ASD.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifndef CAMXCASDSTATSPROCESSOR_H
#define CAMXCASDSTATSPROCESSOR_H

#include "camxistatsprocessor.h"
#include "camxstatscommon.h"
#include "camxstatsparser.h"
#include "camxtuningdatamanager.h"
#include "camxutils.h"
#include "chiasdinterface.h"
#include "chistatspropertydefines.h"

CAMX_NAMESPACE_BEGIN

UINT32 const NumOfTuningMode = 1;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief The class that implements IStatsProcessor for ASD.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
class CASDStatsProcessor final : public IStatsProcessor
{
public:
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Create
    ///
    /// @brief  Create the object for CASDStatsProcessor.
    ///
    /// @param  ppASDStatsProcessor Pointer to CASDStatsProcessor
    ///
    /// @return CamxResultSuccess if successful
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static CamxResult Create(
        IStatsProcessor**   ppASDStatsProcessor);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Initialize
    ///
    /// @brief  Used to initialize the class.
    ///
    /// @param  pInitializeData Pointer to inital settings
    ///
    /// @return CamxResultSuccess if successful
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual CamxResult Initialize(
        const StatsInitializeData*  pInitializeData);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ExecuteProcessRequest
    ///
    /// @brief  Executes the algorithm for a request.
    ///
    /// @param  pStatsProcessRequestDataInfo Pointer to process request information
    ///
    /// @return CamxResultSuccess if successful
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual CamxResult ExecuteProcessRequest(
        const StatsProcessRequestData*  pStatsProcessRequestDataInfo);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetDependencies
    ///
    /// @brief  Get the the list of dependencies from all stats processors.
    ///
    /// @param  pStatsProcessRequestDataInfo    Pointer to process request information
    /// @param  pStatsDependency                Pointer to stats depedencies
    ///
    /// @return CamxResultSuccess if successful
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual CamxResult GetDependencies(
        const StatsProcessRequestData*  pStatsProcessRequestDataInfo,
        StatsDependency*                pStatsDependency);

protected:
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ~CASDStatsProcessor
    ///
    /// @brief  Destructor
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ~CASDStatsProcessor();

private:
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// CASDStatsProcessor
    ///
    /// @brief  Constructor.
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CASDStatsProcessor();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetAlgorithmInput
    ///
    /// @brief  Gets the required inputs for the core algorithm
    ///
    /// @param  pInput                       Pointer to the core input data
    ///
    /// @return Success or failure
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult GetAlgorithmInput(
        ASDAlgoInputList*               pInput);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetAlgorithmOutputBuffers
    ///
    /// @brief  Populates the algo output structure with required buffers
    ///
    /// @param  pStatsProcessRequestDataInfo Pointer to process request information
    /// @param  pOutput                      Pointer to the core output data
    ///
    /// @return Success or failure
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult GetAlgorithmOutputBuffers(
        const StatsProcessRequestData*  pStatsProcessRequestDataInfo,
        ASDAlgoOutputList*              pOutput);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// SetFaceROISettings
    ///
    /// @brief  Translate PropertyFaceROIInfo to StatsFaceInformation
    ///
    /// @param  pFaceInfo    Pointer to StatsFaceInformation
    /// @param  pFaceROIInfo Pointer to PropertyFaceROIInfo
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    VOID SetFaceROISettings(
        StatsFaceInformation* pFaceInfo,
        FaceROIInformation*   pFaceROIInfo);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ReadAECframeInfo
    ///
    /// @brief  Read AEC Frame Information
    ///
    /// @param  pFrameInfo Pointer to AEC Frame Information
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    VOID ReadAECframeInfo(
        AECFrameInformation* pFrameInfo);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ReadAECInternal
    ///
    /// @brief  Read AEC Internal Information
    ///
    /// @param  pAECOutInternal Pointer to AEC Internal Information
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    VOID ReadAECInternal(
        AECOutputInternal* pAECOutInternal);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ReadAWBInternal
    ///
    /// @brief  Read AWB Internal Information
    ///
    /// @param  pAWBOutputInternal Pointer to AWB Internal Information
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    VOID ReadAWBInternal(
        AWBOutputInternal* pAWBOutputInternal);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ReadBHIST
    ///
    /// @brief  Read HIstogram stats
    ///
    /// @param  pStats                Pointer to stats data read from meta data pool
    /// @param  pStatsBayerHistData   Pointer to the stats bayer hist which is passed to asd process
    ///
    /// @return Success or failure
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult ReadBHIST(
        VOID* pStats,
        StatsBayerHist* pStatsBayerHistData);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// SendAlgoSetParam
    ///
    /// @brief  Send Algo Set params to algorithm
    ///
    /// @param  pInitializeData Pointer to get tuning param manager information
    ///
    /// @return Success or failure
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult SendAlgoSetParam(
        const StatsInitializeData* pInitializeData);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// PublishDefaultOutput
    ///
    /// @brief  Publishes the default configuration
    ///
    /// @param  pOutput Pointer to get output data
    ///
    /// @return CamxResultSuccess if successful
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult PublishDefaultOutput(
        ASDAlgoOutputList* pOutput);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// PublishSkippedFrameOutput
    ///
    /// @brief  Publish ASD frame control from previous frame property pool
    ///
    /// @return Success or failure
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult PublishSkippedFrameOutput() const;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ParseISPStats
    ///
    /// @brief  Arrange ISP HW stats in the expected algorithm format.
    ///
    /// @param  pStatsProcessRequestDataInfo Pointer to process request information
    ///
    /// @return Success or failure
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult ParseISPStats(
        const StatsProcessRequestData* pStatsProcessRequestDataInfo);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// PublishMetadata
    ///
    /// @brief  Publish ASD output
    ///
    /// @param  pOutput                      Pointer to algo output information
    ///
    /// @return Success or failure
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult PublishMetadata(
        ASDAlgoOutputList*              pOutput);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// PublishFrameControlToMainMetadata
    ///
    /// @brief  Publish ASD frame control data
    ///
    /// @param  pOutput                      Pointer to algo output info
    ///
    /// @return Success or failure
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult PublishFrameControlToMainMetadata(
        ASDAlgoOutputList*             pOutput);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// RetrieveOutput
    ///
    /// @brief  Populate ASD property data
    ///
    /// @param  pAlgoOutput                  Pointer to algo output info
    /// @param  pOutput                      Pointer to property output
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    VOID RetrieveOutput(
        const ASDAlgoOutputList* pAlgoOutput,
        ASDOutput*               pOutput);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// PublishExternalCameraMetadata
    ///
    /// @brief  Publish ASD output data to meta tag
    ///
    /// @param  pOutput                      Pointer to algo output info
    ///
    /// @return Success or failure
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult PublishExternalCameraMetadata(
        ASDAlgoOutputList*             pOutput);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// PublishToInternalMetadata
    ///
    /// @brief  Publishes the algorithm output to the internal metadata pool
    ///
    /// @return Success or failure
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult PublishToInternalMetadata();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// SetAlgoChromatix
    ///
    /// @brief  Sets the required inputs parameters for the core algorithm
    ///
    /// @param  pInputTuningModeData Pointer to Chi Tuning mode
    /// @param  pTuningData          Pointer to o/p data
    ///
    /// @return Success or failure
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult SetAlgoChromatix(
        ChiTuningModeParameter* pInputTuningModeData,
        StatsTuningData*        pTuningData);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ProcessSetParams
    ///
    /// @brief  Sends the required set parameters for the core algorithm
    ///
    /// @param  pInputTuningModeData Pointer to Chi tuning data
    ///
    /// @return Success or failure
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult ProcessSetParams(
        ChiTuningModeParameter* pInputTuningModeData);

    CASDStatsProcessor(const CASDStatsProcessor&)               = delete;   ///< Do not implement copy constructor
    CASDStatsProcessor& operator=(const CASDStatsProcessor&)    = delete;   ///< Do not implement assignment operator

    Node*                   m_pNode;                         ///< Pointer to owning StatsProcessor node
    CREATEASD               m_pfnCreate;                     ///< Pointer to algorithm entry function
    CHIASDAlgorithm*        m_pCHIASDAlgorithm;              ///< Pointer to instance of ASD algorithm interface
    StatsParser*            m_pStatsParser;                  ///< ISP stats parser
    StatsBayerHist          m_statsBayerHistData;            ///< Holds algorithm bayer hist data info
    ASDAlgoAECAWBInfo       m_expInfo;                       ///< Holds Exposure information input for ASD Algorithm
    ASDAlgoSceneInfo        m_sceneInfo;                     ///< Holds algorithm ASD scene info like Bakclight,
                                                             ///< snow scene, landscape, portriat and HDR
    CamX::OSLIBRARYHANDLE   m_hHandle;                       ///< Handle for algo lib.
    TuningMode              m_tuningMode[NumOfTuningMode];   ///< Number of tuning modes
    StatsTuningData         m_tuningData;                    ///< Tuning data.
    PropertyID              m_BHistogramId;                  ///< Histogram ID.
    const StaticSettings*   m_pStaticSettings;               ///< Pointer to camera settings
    StatsFaceInformation    m_faceInfo;                      ///< Face Info
    StatsDimension          m_sensorDim;                     ///< Sensor Dimension
};

CAMX_NAMESPACE_END

#endif // CAMXCASDStatsProcessor_H
